home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / dev / devSCSIC90Int.h < prev    next >
C/C++ Source or Header  |  1992-12-18  |  20KB  |  541 lines
  1.  /* 
  2.  * devSCSIC90Int.h --
  3.  *
  4.  *    Def'ns specific to the SCSI NCR 53C9X Host Adaptor.  This adaptor is
  5.  *    based on the NCR 53C90 chip.
  6.  *    The 53C90 supports connect/dis-connect.
  7.  *
  8.  * Copyright 1991 Regents of the University of California
  9.  * Permission to use, copy, modify, and distribute this
  10.  * software and its documentation for any purpose and without
  11.  * fee is hereby granted, provided that the above copyright
  12.  * notice appear in all copies.  The University of California
  13.  * makes no representations about the suitability of this
  14.  * software for any purpose.  It is provided "as is" without
  15.  * express or implied warranty.
  16.  *
  17.  *$Header: /cdrom/src/kernel/Cvsroot/kernel/dev/devSCSIC90Int.h,v 1.1 91/10/30 12:16:03 mgbaker Exp $ SPRITE (Berkeley)
  18.  */
  19.  
  20. #ifndef _DEVSCSIC90INT
  21. #define _DEVSCSIC90INT
  22.  
  23. #include "devSCSIC90Mach.h"
  24.  
  25.  
  26. /*
  27.  *
  28.  *      Definitions for Sun's third(?) variant on the SCSI device interface.
  29.  *    The reference for the 53C90 is the NCR Advanced SCSI Processor
  30.  *    User's Guide, Micro-electronics Division, Revision 2.1, Aug. 1989.
  31.  */
  32.  
  33. /*
  34.  * The control registers have different definitions depending on whether
  35.  * you are reading or writing them.  The fields require byte accesses, even
  36.  * though they are full-word aligned.
  37.  */
  38. typedef struct ReadRegs {
  39.     unsigned char xCntLo;    /* LSB of transfer count2er. */
  40.     unsigned char pad1;
  41.     unsigned char pad2;
  42.     unsigned char pad3;
  43.     unsigned char xCntHi;    /* MSB of transfer counter. */
  44.     unsigned char pad5;
  45.     unsigned char pad6;
  46.     unsigned char pad7;
  47.     unsigned char FIFO;        /* FIFO. */
  48.     unsigned char pad9;
  49.     unsigned char pad10;
  50.     unsigned char pad11;
  51.     unsigned char command;    /* Command register. */
  52.     unsigned char pad13;
  53.     unsigned char pad14;
  54.     unsigned char pad15;
  55.     unsigned char status;    /* Status register. */
  56.     unsigned char pad17;
  57.     unsigned char pad18;
  58.     unsigned char pad19;
  59.     unsigned char interrupt;    /* Interrupt register. */
  60.     unsigned char pad21;
  61.     unsigned char pad22;
  62.     unsigned char pad23;
  63.     unsigned char sequence;    /* Sequnce step register. */
  64.     unsigned char pad25;
  65.     unsigned char pad26;
  66.     unsigned char pad27;
  67.     unsigned char FIFOFlags;    /* FIFO flags. */
  68.     unsigned char pad29;
  69.     unsigned char pad30;
  70.     unsigned char pad31;
  71.     unsigned char config1;    /* Configuration 1. */
  72.     unsigned char pad33;
  73.     unsigned char pad34;
  74.     unsigned char pad35;
  75.     unsigned char reserved1;    /* NCR reserved. */
  76.     unsigned char pad37;
  77.     unsigned char pad38;
  78.     unsigned char pad39;
  79.     unsigned char reserved2;    /* NCR reserved. */
  80.     unsigned char pad41;
  81.     unsigned char pad42;
  82.     unsigned char pad43;
  83.     unsigned char config2;    /* Configuration 2. */
  84.     unsigned char pad45;
  85.     unsigned char pad46;
  86.     unsigned char pad47;
  87.     unsigned char config3;    /* Configuration 3. */
  88.     unsigned char pad49;
  89.     unsigned char pad50;
  90.     unsigned char pad51;
  91.     unsigned char reserved3;    /* NCR reserved. */
  92. } ReadRegs;
  93.  
  94. /*
  95.  * The following format applies when writing the registers.
  96.  */
  97. typedef struct WriteRegs {
  98.     unsigned char xCntLo;    /* LSB of transfer counter. */
  99.     unsigned char pad1;
  100.     unsigned char pad2;
  101.     unsigned char pad3;
  102.     unsigned char xCntHi;    /* MSB of transfer counter. */
  103.     unsigned char pad5;
  104.     unsigned char pad6;
  105.     unsigned char pad7;
  106.     unsigned char FIFO;        /* FIFO. */
  107.     unsigned char pad9;
  108.     unsigned char pad10;
  109.     unsigned char pad11;
  110.     unsigned char command;    /* Command register. */
  111.     unsigned char pad13;
  112.     unsigned char pad14;
  113.     unsigned char pad15;
  114.     unsigned char destID;    /* Destination ID. */
  115.     unsigned char pad17;
  116.     unsigned char pad18;
  117.     unsigned char pad19;
  118.     unsigned char timeout;    /* (Re)selection timeout. */
  119.     unsigned char pad21;
  120.     unsigned char pad22;
  121.     unsigned char pad23;
  122.     unsigned char synchPer;    /* Synchronous period. */
  123.     unsigned char pad25;
  124.     unsigned char pad26;
  125.     unsigned char pad27;
  126.     unsigned char synchOffset;    /* Synchronous offset. */
  127.     unsigned char pad29;
  128.     unsigned char pad30;
  129.     unsigned char pad31;
  130.     unsigned char config1;    /* Configuration 1. */
  131.     unsigned char pad33;
  132.     unsigned char pad34;
  133.     unsigned char pad35;
  134.     unsigned char clockConv;    /* Clock conversion factor. */
  135.     unsigned char pad37;
  136.     unsigned char pad38;
  137.     unsigned char pad39;
  138.     unsigned char test;        /* Test mode. */
  139.     unsigned char pad41;
  140.     unsigned char pad42;
  141.     unsigned char pad43;
  142.     unsigned char config2;    /* Configuration 2. */
  143.     unsigned char pad45;
  144.     unsigned char pad46;
  145.     unsigned char pad47;
  146.     unsigned char config3;    /* Configuration 3. */
  147.     unsigned char pad49;
  148.     unsigned char pad50;
  149.     unsigned char pad51;
  150.     unsigned char resFIFO;    /* Reserve FIFO byte. */
  151. } WriteRegs;
  152.  
  153. /*
  154.  * The control register layout.
  155.  */
  156. typedef    struct    CtrlRegs {
  157.     union {
  158.     struct    ReadRegs    read;        /* scsi bus ctrl, read reg. */
  159.     struct    WriteRegs    write;        /* scsi bus crl, write reg. */
  160.     } scsi_ctrl;
  161. } CtrlRegs;
  162.  
  163.  
  164. /*
  165.  * Control bits in the 53C90 Command Register.
  166.  * The command register is a two deep, 8-bit read/write register.
  167.  * Up to 2 commands may be stacked in the command register.
  168.  * Reset chip, reset SCSI bus and target stop DMA execute immediately,
  169.  * all others wait for the previous command to complete.  Reading the
  170.  * command register has no effect on its contenets.
  171.  */
  172. #define    CR_DMA        0x80    /* If set, command is a DMA instruction. */
  173. #define CR_CMD        0x7F    /* The command code bits [6:0]. */
  174.  
  175. /* Miscellaneous group. */
  176. #define    CR_NOP        0x00    /* NOP. */
  177. #define    CR_FLSH_FIFO    0x01    /* Flush FIFO. */
  178. #define    CR_RESET_CHIP    0x02    /* Reset chip. */
  179. #define    CR_RESET_BUS    0x03    /* Reset SCSI bus. */
  180. /* Disconnected state group. */
  181. #define    CR_RESLCT_SEQ    0x40    /* Reselect sequence. */
  182. #define    CR_SLCT_NATN    0x41    /* Select without ATN sequence. */
  183. #define    CR_SLCT_ATN    0x42    /* Select with ATN sequence. */
  184. #define    CR_SLCT_ATNS    0x43    /* Select with ATN and stop sequence. */
  185. #define    CR_EN_SLCT    0x44    /* Enable selection/reselection. */
  186. #define    CR_DIS_SLCT    0x45    /* Disable selection/reselection. */
  187. #define    CR_SLCT_ATN3    0x46    /* Select ATN3. */
  188. /* Target state group. */
  189. #define    CR_SEND_MSG    0x20    /* Send message. */
  190. #define    CR_SEND_STATUS    0x21    /* Send status. */
  191. #define    CR_SEND_DATA    0x22    /* Send data. */
  192. #define    CR_DIS_SEQ    0x23    /* Disconnect sequence. */
  193. #define    CR_TERM_SEQ    0x24    /* Terminate sequence. */
  194. #define    CR_TARG_COMP    0x25    /* Target command complete sequence. */
  195. #define    CR_DISCONNECT    0x27    /* Disconnect. */
  196. #define    CR_REC_MSG    0x28    /* Receive message. */
  197. #define    CR_REC_CMD    0x29    /* Receive command sequence. */
  198. #define    CR_REC_DATA    0x2A    /* Receive data. */
  199. #define    CR_TARG_ABRT    0x06    /* Target abort sequence. */
  200. /* #define    CR_REC_CMD    0x2B    Another receive command sequence? */
  201. /* Initiator state group */
  202. #define    CR_XFER_INFO    0x10    /* Transfer information. */
  203. #define    CR_INIT_COMP    0x11    /* Initiator command complete sequence. */
  204. #define    CR_MSG_ACCPT    0x12    /* Message accepted. */
  205. #define    CR_XFER_PAD    0x18    /* Transfer pad. */
  206. #define    CR_SET_ATN    0x1A    /* Set ATN. */
  207. #define    CR_RESET_ATN    0x1B    /* Reset ATN. */
  208.  
  209. #define C1_SLOW        0x80    /* Slow cable mode. */
  210. #define    C1_REPORT    0x40    /* Disable reporting of interrupts from the
  211.                  * scsi bus reset command. */
  212. #define C1_PARITY_TEST    0x20    /* Enable parity test feature. */
  213. #define C1_PARITY    0x10    /* Enable parity checking. */
  214. #define C1_TEST        0x08    /* Enable chip test mode. */
  215. #define C1_BUS_ID    0x07    /* Bus ID. */
  216.  
  217. #define C2_RESERVE_FIFO 0x80    /* Reserve fifo byte. */
  218. #define C2_PHASE_LATCH    0x40    /* Enable phase latch. */
  219. #define C2_BYTE_CONTROL    0x20    /* Enable byte control. */
  220. #define C2_DREQ_HIGH    0x10    /* Set the DREQ output to high impedence. */
  221. #define C2_SCSI2    0x08    /* Enable SCSI2 stuff. */
  222. #define C2_BAD_PARITY    0x04    /* Abort if bad parity detected. */
  223. #define C2_REG_PARITY    0x02    /* No idea. (see the documentation). */
  224. #define C2_DMA_PARITY    0x01    /* Enable parity on DMA transfers. */
  225.  
  226. #define C3_RESIDUAL    0x04    /* Save residual byte. */
  227. #define C3_ALT_DMA    0x02    /* Alternate DMA mode. */
  228. #define C3_THRESHOLD8    0x01    /* Don't DMA until there are 8 bytes. */
  229.  
  230. /*
  231.  * Bits in the 53C90 Status register (read only).
  232.  * This register contains flags that indicate certain events have occurred.
  233.  * Bits 7-3 are latched until the interrupt register is read.  The phase
  234.  * bits are not normally latched.  The interrupt bit (SR_INT) may be polled.
  235.  * Hardware reset or software reset or a read from the interrupt register
  236.  * will release an active INT signal and also clear this bit.
  237.  * See pages 15-16 for which bits cause interrupts and for how to clear them.
  238.  */
  239. #define    SR_INT        0x80    /* ASC interrupting processor. */
  240. #define    SR_GE        0x40    /* Gross error. */
  241. #define    SR_PE        0x20    /* Parity error. */
  242. #define    SR_TC        0x10    /* Terminal count. */
  243. #define    SR_VGC        0x08    /* Valid group code. */
  244. #define    SR_PHASE    0x07    /* Phase bits. */
  245. #define    SR_DATA_OUT    0x00    /* Data out w.r.t. initiator. */
  246. #define    SR_DATA_IN    0x01    /* Data in. */
  247. #define    SR_COMMAND    0x02    /* Command. */
  248. #define    SR_STATUS    0x03    /* Status. */
  249. #define    SR_MSG_OUT    0x06    /* Message out w.r.t. initiator. */
  250. #define    SR_MSG_IN    0x07    /* Message in. */
  251.  
  252. /*
  253.  * Program/human-level description of phases.  The controller combines
  254.  * the arbitration, selection and command phases into one big "selection"
  255.  * phase.  Likewise, the status and msg-in phases are combined, but you can
  256.  * have one by itself.  The bus free phase isn't represented by phase bits
  257.  * in this controller, but rather by a disconnect after the MSG_IN phase.
  258.  * We use these defines to be the "last phase" we were in, and the phases
  259.  * above (SR_MSG_OUT, etc) to be the phase we are currently in.  Because
  260.  * of the combined phases, this makes the state machine easier if these
  261.  * aren't symmetrical.
  262.  */
  263. #define    PHASE_BUS_FREE        0x0
  264. #define    PHASE_SELECTION        0x1
  265. #define    PHASE_DATA_OUT        0x2
  266. #define    PHASE_DATA_IN        0x3
  267. #define    PHASE_STATUS        0x4
  268. #define    PHASE_MSG_IN        0x5
  269. #define    PHASE_MSG_OUT        0x6
  270. #define    PHASE_STAT_MSG_IN    0x7
  271. #define    PHASE_RDY_DISCON        0x8
  272. #define    PHASE_COMMAND           0xa
  273. #define    PHASE_SYNCH             0xb
  274.  
  275. /*
  276.  * Fifo flags register.
  277.  */
  278. #define    FIFO_BYTES_MASK    0x1F
  279.  
  280. /*
  281.  * Destination ID register for write.destID(write-only).
  282.  */
  283. #define    DEST_ID_MASK    0x07    /* Lowest 3 bits give binary-encoded id. */
  284.  
  285. /*
  286.  * Timeout period to load into write.timeout field:  the usual value
  287.  * is 250ms to meet ANSI standards.  To get the register value, we do
  288.  * (timeout period) * (CLK frequency) / 8192 * (clock conversion factor).
  289.  * The clock conversion factor is defined in the write.clockConv register.
  290.  * The values are
  291.  *    2    for    10MHz
  292.  *    3    for    15MHz
  293.  *    4    for    20MHz
  294.  *    5    for    25MHz        153 is reg val
  295.  */
  296. #define    SELECT_TIMEOUT    153
  297.  
  298. /*
  299.  * Interrupt register. (read-only).  Used in conjuction with the status
  300.  * register and sequence step register to determine the cause of an interrupt.
  301.  * Reading this register when the interrupt output is true will clear all
  302.  * three registers.
  303.  */
  304. #define    IR_SCSI_RST    0x80    /* SCSI reset detected. */
  305. #define    IR_ILL_CMD    0x40    /* Illegal command. */
  306. #define    IR_DISCNCT    0x20    /* Target disconnected or time-out. */
  307. #define    IR_BUS_SERV    0x10    /* Another device wants bus service. */
  308. #define    IR_FUNC_COMP    0x08    /* Function complete. */
  309. #define    IR_RESLCT    0x04    /* Reselected. */
  310. #define    IR_SLCT_ATN    0x02    /* Selected with ATN. */
  311. #define    IR_SLCT        0x01    /* Selected. */
  312.  
  313. /*
  314.  * sequence register. (read-only). Used in conjunction with the status
  315.  * register and interrupt registers to determine partial completion
  316.  * of last action. In initiator mode, which is all we do, the only
  317.  * action which will set the sequence bits is the selection phase.
  318.  */
  319.  
  320. #define SEQ_MASK        0x04    /* mask to isolate sequence bits */
  321.  
  322. /*
  323.  * These are interpreted with the interrupt reg bits. See p.40-41
  324.  * of the NCR 53C90 Enhanced SCSI Processor Data Manual Rev 3.0
  325.  */
  326.  
  327. #define SEQ_NO_SEL           0x00    /* when IR == 0x20        */
  328. #define SEQ_NO_MSG           0x00    /* when IR == 0x18        */
  329. #define SEQ_NO_CMD           0x02    /* when IR == 0x18        */
  330. #define SEQ_CMD_INCOMPLETE   0x03
  331. #define SEQ_COMPLETE         0x04
  332.  
  333. /*
  334.  * The transfer size is limited to 16 bits since the scsi ctrl transfer
  335.  * counter is only 2 bytes.  A 0 value means the biggest transfer size
  336.  * (2 ** 16) == 64k.
  337.  */
  338. #define MAX_TRANSFER_SIZE    (64 * 1024)
  339.  
  340.  
  341. /*
  342.  * Misc defines 
  343.  */
  344.  
  345. extern int devSCSIC90Debug;
  346.  
  347. /* Forward declaration. */
  348. typedef struct Controller Controller;
  349.  
  350. /*
  351.  * Device - The data structure containing information about a device. One of
  352.  * these structure is kept for each attached device. Note that is structure
  353.  * is casted into a ScsiDevice and returned to higher level software.
  354.  * This implies that the ScsiDevice must be the first field in this
  355.  * structure.
  356.  */
  357.  
  358. typedef struct Device {
  359.     ScsiDevice handle;            /* Scsi Device handle. This is the only
  360.                         * part of this structure visible to
  361.                      * higher-level software. MUST BE FIRST
  362.                      * FIELD IN STRUCTURE. */
  363.     int    targetID;            /* SCSI Target ID of this device. Note
  364.                      * that the LUN is stored in the device
  365.                      * handle. */
  366.     Controller *ctrlPtr;        /* Controller to which device is
  367.                      * attached. */
  368.                     /* The following part of this structure
  369.                      * is used to handle SCSI commands that
  370.                      * return CHECK status. To handle the
  371.                      * REQUEST SENSE command we must:
  372.                      * 1) Save the state of the current
  373.                      * command into the "struct
  374.                      * FrozenCommand".
  375.                      * 2) Submit a request sense command
  376.                      * formatted in SenseCmd to the device.
  377.                      */
  378.     struct FrozenCommand {               
  379.     ScsiCmd    *scsiCmdPtr;           /* The frozen command. */
  380.     unsigned char statusByte;     /* It's SCSI status byte, Will always
  381.                      * have the check bit set. */
  382.     int amountTransferred;        /* Number of bytes transferred by this 
  383.                          * command. */
  384.     } frozen;    
  385.     char senseBuffer[DEV_MAX_SENSE_BYTES]; /* Data buffer for request sense */
  386.     ScsiCmd        SenseCmd;         /* Request sense command buffer. */
  387.     ScsiCmd        *scsiCmdPtr;      /* The active command */ 
  388.     Address             savedDataPtr;   /* for SCSI_SAVE_DATA_POINTER and */
  389.     int                 savedDataLen;   /* ...SCSI_RESTORE_POINTERS cmds    */
  390.     int        residual;        /* Residual bytes in xfer counter. */
  391.     unsigned char    commandStatus;    /* Status received from device. */
  392.     int        lastPhase;        /* The scsi phase we were last in. */
  393.     int        dmaState;        /* DMA state for this device
  394.                      * defined below. */
  395.     unsigned char       messageBuf[5];  /* msg byte buffer */
  396.     unsigned char       messageBufLen;
  397.     unsigned char       synchOffset;    /* Max # of REQs w/o an ACK */
  398.     unsigned char       synchPeriod;    /* Min # cycles between REQs */
  399.     unsigned char       msgFlag;  
  400. } Device;
  401.  
  402. /* 
  403.  * msgFlag definitions
  404.  */
  405. #define REQEXTENDEDMSG       0x01       /* request an extended msg */
  406. #define STARTEXTENDEDMSG     0x02       /* processing xtended msg */
  407. #define ENABLEEXTENDEDMSG    0x04       /* enable extended msgs */
  408.  
  409. /*
  410.  * Controller - The Data structure describing a sun SCSIC90 controller. One
  411.  * of these structures exists for each active SCSIC90 HBA on the system. Each
  412.  * controller may have from zero to 56 (7 targets each with 8 logical units)
  413.  * devices attached to it. 
  414.  */
  415. struct Controller {
  416.     volatile CtrlRegs    *regsPtr;    /* Pointer to the registers of
  417.                      * this controller. */
  418.     char            *name;        /* String for error message for this
  419.                      * controller. */
  420.     DevCtrlQueues    devQueues;    /* Device queues for devices attached
  421.                      * to this controller. */
  422.     Sync_Semaphore    mutex;        /* Lock protecting controller's data
  423.                      * structures. */
  424.     Device            *devPtr;      /* Current active command. */
  425.     Device            *devicePtr[8][8];    /* Pointers to the device attached to
  426.                      * the controller index by
  427.                      * [targetID][LUN].  NIL if device not
  428.                      * attached yet. Zero if device
  429.                      * conflicts with HBA address. */
  430.     unsigned int        devQueuesMask;  /* Map of device queues.
  431.                      *  1 = dev available; 0 = dev busy. */
  432.     Device            *interruptDevPtr; /* device interrupted by reconnect */
  433. #ifdef ds5000
  434.     volatile int *dmaRegPtr;    /* Pointer to DMA register. */
  435.     char    *buffer;        /* SCSI buffer address. */
  436.     int        slot;            /* Slot that this controller is in. */
  437. #endif
  438. };
  439.  
  440. /*
  441.  * Possible values for the dmaState state field of a controller.
  442.  *
  443.  * DMA_RECEIVE  - data is being received from the device, such as on
  444.  *    a read, inquiry, or request sense.
  445.  * DMA_SEND     - data is being send to the device, such as on a write.
  446.  * DMA_INACTIVE - no data needs to be transferred.
  447.  */
  448.  
  449. #define DMA_RECEIVE  0x0
  450. #define    DMA_SEND     0x2
  451. #define    DMA_INACTIVE 0x4
  452.  
  453. /* temporary unti new scsiHBA.h is installed */
  454. #define    SCSI_EXTENDED_MSG_SYNC 0x01
  455.  
  456. /*
  457.  * Test, mark, and unmark the device as busy.
  458.  */
  459. #define    IS_CTRL_FREE(ctrlPtr) \
  460.                 ((ctrlPtr)->devPtr == (Device *)NIL)
  461. #define    SET_CTRL_FREE(ctrlPtr) \
  462.                 PUTCIRCBUF(CSTR, "c free "); \
  463.                 PUTCIRCNULL; \
  464.                 (ctrlPtr)->devPtr = (Device *)NIL;
  465. #define    SET_CTRL_BUSY(ctrlPtr,devPtr) \
  466.                 PUTCIRCBUF(CSTR, "c busy "); \
  467.                 PUTCIRCNULL; \
  468.                 (ctrlPtr)->devPtr = devPtr;
  469. #define    IS_INTERRUPT_DEV(cPtr,dPtr,rPtr) \
  470.                 (((cPtr)->interruptDevPtr == (dPtr)) && \
  471.          ((dPtr)->scsiCmdPtr == (rPtr)))
  472. #define    IS_DEV_FREE(devPtr) \
  473.                 ((devPtr)->ctrlPtr->devQueuesMask & (1 << (devPtr)->targetID))
  474. #define    SET_DEV_FREE(devPtr) \
  475.                 (devPtr)->ctrlPtr->devQueuesMask |= (1<<(devPtr)->targetID);\
  476.                 PUTCIRCBUF(CSTR, "d free "); \
  477.                 PUTCIRCBUF(CBYTE, (char *)((devPtr)->targetID)); \
  478.                 PUTCIRCBUF(CSTR, "; mask "); \
  479.                 PUTCIRCBUF(CBYTE, (char *)((devPtr)->ctrlPtr->devQueuesMask)); \
  480.                 PUTCIRCNULL; \
  481.         (devPtr)->scsiCmdPtr = (ScsiCmd *) NIL;
  482. #define    SET_DEV_BUSY(devPtr,cmdPtr)  \
  483.                 (devPtr)->ctrlPtr->devQueuesMask &= ~(1<<(devPtr)->targetID);\
  484.                 PUTCIRCBUF(CSTR, "d busy "); \
  485.                 PUTCIRCBUF(CBYTE, (char *)((devPtr)->targetID)); \
  486.                 PUTCIRCBUF(CSTR, "; mask "); \
  487.                 PUTCIRCBUF(CBYTE, (char *)((devPtr)->ctrlPtr->devQueuesMask)); \
  488.                 PUTCIRCNULL; \
  489.         (devPtr)->scsiCmdPtr = (cmdPtr);
  490.  
  491. void             DevReset _ARGS_ ((Controller *ctrlPtr));
  492. void             DevStartDMA _ARGS_ ((Controller *ctrlPtr));
  493. Boolean          DevEntryAvailProc _ARGS_ ((ClientData clientData,
  494.                      List_Links *newRequestPtr));
  495.  
  496. extern Controller *Controllers[MAX_SCSIC90_CTRLS];
  497.  
  498. /* 
  499.  * Min/max values for synchronous xfer as given in the NCR manual
  500.  */
  501. #define MAX_SYNCH_PERIOD 35
  502. #define MIN_SYNCH_PERIOD 5
  503. #define MAX_SYNCH_OFFSET 15
  504. #define MIN_SYNCH_OFFSET 0
  505.  
  506. /*
  507.  * These macros convert the synch_period between units of
  508.  * 4ns, for the scsi protocol, and clock units, which is what
  509.  * the NCR chip wants.
  510.  * Each cycle is 1000/(CLOCKCONV*5) ns, so (n*4) ns equals
  511.  * (n*4)/(1000/(CLOCKCONV*5)) = (n*CLOCKCONV/50) cycles.
  512.  */
  513. #define SCSI_TO_NCR(x)  \
  514.     ((x)*CLOCKCONV/50) + \
  515.     (( ((x)*CLOCKCONV/50) * (50/CLOCKCONV) < (x)) ? 1 : 0)
  516. #define NCR_TO_SCSI(x) ((x)*50/CLOCKCONV)
  517.  
  518. /*
  519.  * debugging junk
  520.  *
  521.  */
  522.  
  523. #define CIRCBUFLEN (1024*10)
  524.  
  525. extern int circhead;
  526. extern char circBuf[CIRCBUFLEN];
  527. extern char numTab[16];
  528.  
  529. #define CSTR 0
  530. #define CBYTE 1
  531. #define CINT 2
  532.  
  533. #define CVTHEX(num,bits)  numTab[((int)num >> bits) & 0x0f]
  534. #define PUTCIRCBUF(a,b) PutCircBuf(a,b)
  535. #define PUTCIRCNULL \
  536.                 circBuf[circHead] = '\0'; \
  537.                 circHead = (circHead + 1) % CIRCBUFLEN;
  538. #endif
  539.  
  540.  
  541.